#pragma once
#include<iostream>
#include<stdlib.h>
using namespace std;

///基模板类matrix
///成员参数：
template <typename T>
class matrix
{
 public:
  //构造函数
  matrix(const int &row=0,const int &col=0,const T*elements = NULL)
    {
      //错误中断操作，用户错误的传入行数和参数时中断程序
      if(row<=0||col<=0)
	{
	  cout<<"invalid input!break...";
	  exit(1);
	}
      else
	{
	  ///通过动态数组完成动态储存矩阵中的数据
	  n_row=row;
	  n_col=col;
	  matrix_elements= new T[n_row*n_col];
	  for (int n=0;n<row*col;n++)
	    {
	      matrix_elements[n]=elements[n];
	    }
	}
      

    }

  ~matrix()
    {
      
    }
  ///重载运算符=，便于矩阵间的赋值
  void operator=(const matrix<T> &M)
    {
      this->n_col=M.n_col;
      this->n_row=M.n_row;
      this->matrix_elements=new T[(M.n_row)*(M.n_row)];
      for(int n=0;n<M.n_row*M.n_row;n++)
	{
	  this->matrix_elements[n]=M.matrix_elements[n];
	}
    }
  ///重载运算符<<，便于直接输出矩阵
  friend ostream& operator<<(ostream& output,const matrix<T>&M)
  {
    int count=0;
    for(int i=0;i<M.n_row;i++)
      {
	for(int j=0;j<M.n_col;j++)
	  {
	    output<<M.matrix_elements[count]<<' ';
	    count++;
	  }
	output <<endl;
      }
    return output;
  }
  ///判断矩阵是否为方阵，是则返回1,否则返回0
  bool is_square()
  {
    if(n_row==n_col)
      {
	return true;
      }
    else
      {
	return false;
      }
  }

  int n_row,n_col;
  T* matrix_elements;
  
};

//派生类行向量RowVector
template<typename T>
class RowVector:public matrix<T>
{
 public:
  RowVector(const int&col,const T*elements)
    :matrix<T>(1,col,elements)
    {}
friend double  operator*(const RowVector<T>& r1,const RowVector<T>& r2)
    {
      double conclusion_op=0;
	 for(int n=0;n<r1.n_col;n++)
	   {
	     conclusion_op+=r1.matrix_elements[n]*r2.matrix_elements[n];
	   }
       return conclusion_op;
    }
 
};

//派生类行向量ColVector
template<typename T>
class ColVector:public matrix<T>
{
 public:
  ColVector(const int &row,const T*elements)
    :matrix<T>(row,1,elements)
    {}

  //重载运算符*（左操作数类型为RowVector，又为ColVector）完成行向量乘列向量
  friend double operator*(const RowVector<T>&r,const ColVector<T>&c)
  //友元函数
    {
      T conclusion_op=0;
      for(int n=0;n<r.n_col;n++)
	{
	  conclusion_op+= r.matrix_elements[n]*c.matrix_elements[n];
	}
      return conclusion_op;
    }

  //重载运算符*（左操作数类型为ColVector，又为RowVector）完成行向量乘列向量
  friend matrix<T> operator*(const ColVector<T>& c,const RowVector<T>& r)
  //友元函数
  {
    T*array_tem=new T[r.n_col*c.n_row];
    int count = 0;
    for(int i=0;i<c.n_row;i++)
      {
	for(int j=0;j<r.n_col;j++)
	  {
	    array_tem[count]=c.matrix_elements[i]*r.matrix_elements[j];
	    count++;
	  }
      }
  }
    friend double operator*(const ColVector<T>& c1,const ColVector<T>& c2)
    {
      double conclusion_op=0;
	 for(int n=0;n<c1.n_row;n++)
	   {
	     conclusion_op+=c1.matrix_elements[n]*c2.matrix_elements[n];
	   }
       return conclusion_op;
    }
  
   
  
};
